home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 001 / pibt3sp1.arc / DISPLAYC.PAS < prev    next >
Pascal/Delphi Source File  |  1985-09-09  |  10KB  |  278 lines
  1. (*----------------------------------------------------------------------*)
  2. (*           Display_Character --- show character received from port    *)
  3. (*----------------------------------------------------------------------*)
  4.  
  5. PROCEDURE Display_Character;
  6.  
  7. (*----------------------------------------------------------------------*)
  8. (*                                                                      *)
  9. (*     Procedure:  Display_Character                                    *)
  10. (*                                                                      *)
  11. (*     Purpose:    Displays character received from comm. port on       *)
  12. (*                 screen/printer/capture file.                         *)
  13. (*                                                                      *)
  14. (*     Calling Sequence:                                                *)
  15. (*                                                                      *)
  16. (*        Display_Character( Ch : CHAR );                               *)
  17. (*                                                                      *)
  18. (*           Ch         --- Character received from Comm. port.         *)
  19. (*                                                                      *)
  20. (*      Calls:   Async_Receive                                          *)
  21. (*               Send_Function_Key                                      *)
  22. (*               Min                                                    *)
  23. (*               Update_Review_Pointers                                 *)
  24. (*               TimeOfDay                                              *)
  25. (*               TimeDiff                                               *)
  26. (*                                                                      *)
  27. (*      Remarks:                                                        *)
  28. (*                                                                      *)
  29. (*         This routine strips out certain characters which             *)
  30. (*         should not be displayed, implements the XON/XOFF protocol    *)
  31. (*         in a simple-minded manner, performs output wrap, and saves   *)
  32. (*         output line in the review the review buffer.                 *)
  33. (*                                                                      *)
  34. (*----------------------------------------------------------------------*)
  35.  
  36. (* STRUCTURED *) CONST
  37.    CR_Ch : CHAR = ^M;
  38.    LF_Ch : CHAR = ^J;
  39.    BL_Ch : CHAR = ' ';
  40.  
  41. VAR
  42.    I    : INTEGER;
  43.    L    : INTEGER;
  44.    Xpos : INTEGER;
  45.    Ypos : INTEGER;
  46.  
  47. (*----------------------------------------------------------------------*)
  48. (*          Update_Review_Pointers --- Update review buffer pointers    *)
  49. (*----------------------------------------------------------------------*)
  50.  
  51. PROCEDURE Update_Review_Pointers;
  52.  
  53. BEGIN (* Update_Review_Pointers *)
  54.  
  55.                                    (* Point to next slot in review buffer *)
  56.  
  57.    Review_Head := Review_Head + 1;
  58.    IF Review_Head > Max_Review_Length THEN
  59.       Review_Head := 1;
  60.                                    (* If we wrapped into last line,       *)
  61.                                    (* update last line pointer            *)
  62.  
  63.    IF Review_Head = Review_Tail THEN
  64.       BEGIN
  65.          Review_Tail := Review_Tail + 1;
  66.          IF Review_Tail > Max_Review_Length THEN
  67.             Review_Tail := 1;
  68.       END;
  69.  
  70.    IF Review_Tail = 0 THEN
  71.       Review_Tail := 1;
  72.  
  73.    Review_Buffer^[Review_Head] := COPY( Review_Line, 1,
  74.                                         MIN( LENGTH( Review_Line ) , 80 ) );
  75.    Review_Line := '';
  76.  
  77. END   (* Update_Review_Pointers *);
  78.  
  79. (*----------------------------------------------------------------------*)
  80.  
  81. BEGIN (* Display_Character *)
  82.                                    (* Get current cursor position *)
  83.    Xpos := WhereX;
  84.    Ypos := WhereY;
  85.                                    (* Select display depending on *)
  86.                                    (* character.                  *)
  87.    CASE ORD( Ch ) OF
  88.  
  89.       NUL  :    ;       (* Strip Nulls              *)
  90.       DEL  :    ;       (* Strip Deletes            *)
  91.       XON  :    ;       (* Strip unattached XONs    *)
  92.  
  93.       XOFF :    BEGIN (* Handle XOFF *)
  94.  
  95.                                (* Wait for XON *)
  96.                    REPEAT
  97.                       DELAY( Tenth_Of_A_Second_Delay );
  98.                       WHILE( NOT ( Async_Receive( Ch ) OR KeyPressed ) ) DO;
  99.                    UNTIL(  ( Ch = CHR( XON ) )  OR  KeyPressed  );
  100.  
  101.                 END   (* Handle XOFF *);
  102.  
  103.       BELL :    IF Not Silent_Mode THEN
  104.                    WRITE( Ch );
  105.  
  106.       HT   :    BEGIN
  107.  
  108.                    L := 9 - WhereX MOD 8;
  109.  
  110.                    FOR I := 1 TO L DO
  111.                       BEGIN
  112.                          WRITE( BL_Ch );
  113.                          IF Review_On THEN
  114.                             Review_Line := Review_Line + ' ';
  115.                       END;
  116.  
  117.                    IF Capture_On THEN
  118.                       FOR I := 1 TO L DO
  119.                          WRITE( Capture_File , BL_Ch );
  120.  
  121.                    IF Printer_On THEN
  122.                       FOR I := 1 TO L DO
  123.                          WRITE( Lst , BL_Ch );
  124.  
  125.                 END;
  126.  
  127.       FF   :    BEGIN
  128.                    ClrScr;
  129.                    IF Capture_On THEN
  130.                       WRITE( Capture_File, Ch );
  131.                    IF Printer_On THEN
  132.                       WRITE( Lst , Ch );
  133.                 END;
  134.  
  135.       CR   :    IF Add_LF THEN
  136.                    BEGIN
  137.                       WRITE( CR_Ch, LF_Ch );
  138.                       Last_Column_Hit := FALSE;
  139.                       IF Capture_On THEN
  140.                          WRITELN( Capture_File );
  141.                       IF Printer_On THEN
  142.                          WRITE( Lst , CR_Ch , LF_Ch );
  143.                       IF Review_On THEN
  144.                          Update_Review_Pointers;
  145.                    END
  146.                 ELSE
  147.                    BEGIN
  148.                       WRITE( CR_Ch );
  149.                       Last_Column_Hit := FALSE;
  150.                       IF Printer_On THEN
  151.                          WRITE( Lst , CR_Ch );
  152.                    END;
  153.  
  154.  
  155.       LF   :    IF NOT Add_LF THEN
  156.                    BEGIN
  157.                       WRITE( LF_Ch );
  158.                       IF Capture_On THEN
  159.                          WRITELN( Capture_File );
  160.                       IF Printer_On THEN
  161.                          WRITE( Lst , LF_Ch );
  162.                       IF Review_On THEN
  163.                          Update_Review_Pointers;
  164.                    END;
  165.  
  166.       ELSE
  167.             BEGIN
  168.                                    (* Remember if last column hit *)
  169.                                    (* so we can wrap properly.    *)
  170.  
  171.                IF ( Xpos = Max_Screen_Col ) THEN
  172.                   IF Last_Column_Hit THEN
  173.                      BEGIN
  174.                         IF Auto_Wrap_Mode THEN
  175.                            BEGIN
  176.                               WRITELN;
  177.                               WRITE( Ch );
  178.                               Last_Column_Hit := FALSE;
  179.                            END
  180.                         ELSE
  181.                            BEGIN
  182.                               WRITE( Ch );
  183.                               GoToXY( Xpos, Ypos );
  184.                            END
  185.                      END
  186.                   ELSE
  187.                      BEGIN
  188.                         WRITE( Ch );
  189.                         GoToXY( Xpos , Ypos );
  190.                         Last_Column_Hit := TRUE;
  191.                      END
  192.                ELSE
  193.                   BEGIN
  194.                      WRITE( Ch );
  195.                      Last_Column_Hit := FALSE;
  196.                   END;
  197.  
  198.                IF Review_On THEN
  199.                   IF LENGTH( Review_Line ) < 80 THEN
  200.                       Review_Line := Review_Line + Ch;
  201.  
  202.                IF Capture_On THEN
  203.                   WRITE( Capture_File, Ch );
  204.  
  205.                IF Printer_On THEN
  206.                   WRITE( Lst , Ch );
  207.  
  208.             END;
  209.  
  210.    END (* CASE *);
  211.                                    (* Check for WAIT string       *)
  212.  
  213.    IF WaitString_Mode THEN
  214.       BEGIN
  215.  
  216.          IF ( NOT ( ORD( Ch ) IN [NUL,DEL,XON,XOFF] ) ) THEN
  217.             BEGIN
  218.                                    (* Add in new character and     *)
  219.                                    (* check if wait string present *)
  220.  
  221.                L := LENGTH( Script_Wait_Save );
  222.  
  223.                IF L < LENGTH( Script_Wait_Text ) THEN
  224.                   Script_Wait_Save := Script_Wait_Save + Ch
  225.                ELSE
  226.                   Script_Wait_Save := COPY( Script_Wait_Save, 2, L - 1 ) + Ch;
  227.  
  228.                IF ( Script_Wait_Text = Script_Wait_Save ) THEN
  229.                   BEGIN
  230.                      Script_Wait_Save   := '';
  231.                      Script_Wait_Found  := TRUE;
  232.                      WaitString_Mode    := FALSE;
  233.                      Really_Wait_String := FALSE;
  234.                      Send_Function_Key( Script_Wait_Reply_Text );
  235.                   END;
  236.  
  237.             END;
  238.                                    (* Check if wait time exhausted *)
  239.          IF WaitString_Mode THEN
  240.             IF ( TimeDiff( Script_Wait_Start , TimeOfDay ) > Script_Wait_Time )
  241.                THEN
  242.                BEGIN
  243.                   Script_Wait_Save   := '';
  244.                   Script_Wait_Found  := FALSE;
  245.                   WaitString_Mode    := FALSE;
  246.                   Really_Wait_String := FALSE;
  247.                   IF ( Script_Wait_Failure > 0 ) THEN
  248.                      Script_Buffer_Pos  := Script_Wait_Failure - 1;
  249.                END;
  250.  
  251.       END;
  252.                                    (* Check for WHEN string       *)
  253.  
  254.    IF When_Mode THEN
  255.       BEGIN
  256.  
  257.          IF ( NOT ( ORD( Ch ) IN [NUL,DEL,XON,XOFF] ) ) THEN
  258.             BEGIN
  259.  
  260.                L := LENGTH( Script_When_Save );
  261.  
  262.                IF L < LENGTH( Script_When_Text ) THEN
  263.                   Script_When_Save := Script_When_Save + Ch
  264.                ELSE
  265.                   Script_When_Save := COPY( Script_When_Save, 2, L - 1 ) + Ch;
  266.  
  267.                IF ( Script_When_Text = Script_When_Save ) THEN
  268.                   BEGIN
  269.                      Script_When_Save := '';
  270.                      Send_Function_Key( Script_When_Reply_Text );
  271.                   END;
  272.  
  273.             END;
  274.  
  275.       END;
  276.  
  277. END   (* Display_Character *);
  278.